home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / ausay / english.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  16.3 KB  |  670 lines
  1. /*
  2.  * *    English to Phoneme rules. *
  3.  * 
  4.  *    Derived from: *
  5.  * 
  6.  *         AUTOMATIC TRANSLATION OF ENGLISH TEXT TO PHONETICS *
  7.  * BY MEANS OF LETTER-TO-SOUND RULES *
  8.  * 
  9.  *            NRL Report 7948 *
  10.  * 
  11.  *              January 21st, 1976 *        Naval Research
  12.  * Laboratory, Washington, D.C. *
  13.  * 
  14.  *
  15.  *    Published by the National Technical Information Service as *
  16.  * document "AD/A021 929". *
  17.  * 
  18.  *
  19.  *
  20.  *    The Phoneme codes: *
  21.  * 
  22.  *        IY    bEEt        IH    bIt
  23.  *        EY    gAte        H (EH?)    gEt
  24.  *        AE    fAt        AA    fAther
  25.  *         O (AO?)    lAWn        OW    lOne
  26.  *        UH    fUll        UW    fOOl
  27.  *        ER    mURdER        AX    About
  28.  *        AH    bUt        AY    hIde
  29.  *        AW    hOW        OY    tOY
  30.  *        U (YU?)    YOU        p    Pack
  31.  *        b    Back        t    Time
  32.  *         (d?)    Dime        k    Coat
  33.  *        g    Goat           f    Fault
  34.  *        v    Vault        TH    eTHer
  35.  *        DH    eiTHer        s    Sue
  36.  *        z    Zoo        SH    leaSH
  37.  *        ZH    leiSure        HH    How
  38.  *        (m?)     suM        n    suN
  39.  *        NG    suNG        l    Laugh
  40.  *        w    Wear        y    Young
  41.  *        r    Rate        CH    CHar
  42.  *        j    Jar        WH    WHere
  43.  * 
  44.  *
  45.  *    Rules are made up of four parts: *
  46.  * 
  47.  *        The left context.
  48.  *        The text to match.
  49.  *         The right context.
  50.  *        The phonemes to substitute for the matched text.
  51.  *
  52.  *    Procedure:
  53.  * 
  54.  *        Seperate each block of letters (apostrophes included) *
  55.  * nd add a space on each side.  For each unmatched *        letter in the
  56.  * word, look through the rules where the *        text to match starts
  57.  * with the letter in the word.  If *        the text to match is found
  58.  * and the right and left *        context patterns also match, output
  59.  * the phonemes for *        that rule and skip to the next unmatched
  60.  * letter. *
  61.  * 
  62.  *
  63.  *    Special Context Symbols: *
  64.  * 
  65.  *        #    One or more vowels *        :    Zero or more
  66.  * consonants *        ^    One consonant. *        .    One
  67.  * of B, D, V, G, J, L, M, N, R, W or Z (voiced *
  68.  * ants) *        %    One of ER, E, ES, ED, ING, ELY (a suffix) *
  69.  * Found in right context only) *        +    One of E, I or Y (a
  70.  * "front" vowel) *
  71.  * 
  72.  */
  73.  
  74.  
  75. /* Context definitions */
  76. static char     Anything[] = "";/* No context requirement */
  77. static char     Nothing[] = " ";/* Context is beginning or end of word */
  78.  
  79. /* Phoneme definitions */
  80. static char     Pause[] = " ";    /* Short silence */
  81. static char     Silent[] = "";    /* No phonemes */
  82.  
  83. #define LEFT_PART    0
  84. #define MATCH_PART    1
  85. #define RIGHT_PART    2
  86. #define OUT_PART    3
  87.  
  88. typedef char   *Rule[4];    /* Rule is an array of 4 character pointers */
  89.  
  90. /* 0 = Punctuation */
  91. /*
  92.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  93.  */
  94. static Rule     punct_rules[] =
  95. {
  96.     {Anything, " ", "'", Silent},
  97.     {Anything, " ", Anything, Pause},
  98.     {Anything, "-", Anything, Silent},
  99.     {".", "'S", Anything, "z"},
  100.     {"#:.E", "'S", Anything, "z"},
  101.     {"#", "'S", Anything, "z"},
  102.     {Anything, "'", Anything, Silent},
  103.     {Anything, ",", Anything, Pause},
  104.     {Anything, ".", Anything, Pause},
  105.     {Anything, "?", Anything, Pause},
  106.     {Anything, "!", Anything, Pause},
  107. };
  108.  
  109.  
  110. /*
  111.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  112.  */
  113. static Rule     A_rules[] =
  114. {
  115.     {Anything, "A", Nothing, "AX"},
  116.     {Nothing, "ARE", Nothing, "AAr"},
  117.     {Nothing, "AR", "O", "AXr"},
  118.     {Anything, "AR", "#", "EHr"},
  119.     {"^", "AS", "#", "EYs"},
  120.     {Anything, "A", "WA", "AX"},
  121.     {Anything, "AW", Anything, "AO"},
  122.     {" :", "ANY", Anything, "EHnIY"},
  123.     {Anything, "A", "^+#", "EY"},
  124.     {"#:", "ALLY", Anything, "AXlIY"},
  125.     {Nothing, "AL", "#", "AXl"},
  126.     {Anything, "AGAIN", Anything, "AXgEHn"},
  127.     {"#:", "AG", "E", "IHj"},
  128.     {Anything, "A", "^+:#", "AE"},
  129.     {" :", "A", "^+ ", "EY"},
  130.     {Anything, "A", "^%", "EY"},
  131.     {Nothing, "ARR", Anything, "AXr"},
  132.     {Anything, "ARR", Anything, "AEr"},
  133.     {" :", "AR", Nothing, "AAr"},
  134.     {Anything, "AR", Nothing, "ER"},
  135.     {Anything, "AR", Anything, "AAr"},
  136.     {Anything, "AIR", Anything, "EHr"},
  137.     {Anything, "AI", Anything, "EY"},
  138.     {Anything, "AY", Anything, "EY"},
  139.     {Anything, "AU", Anything, "AO"},
  140.     {"#:", "AL", Nothing, "AXl"},
  141.     {"#:", "ALS", Nothing, "AXlz"},
  142.     {Anything, "ALK", Anything, "AOk"},
  143.     {Anything, "AL", "^", "AOl"},
  144.     {" :", "ABLE", Anything, "EYbAXl"},
  145.     {Anything, "ABLE", Anything, "AXbAXl"},
  146.     {Anything, "ANG", "+", "EYnj"},
  147.     {Anything, "A", Anything, "AE"},
  148. };
  149.  
  150.  
  151. /*
  152.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  153.  */
  154. static Rule     B_rules[] =
  155. {
  156.     {Nothing, "BE", "^#", "bIH"},
  157.     {Anything, "BEING", Anything, "bIYIHNG"},
  158.     {Nothing, "BOTH", Nothing, "bOWTH"},
  159.     {Nothing, "BUS", "#", "bIHz"},
  160.     {Anything, "BUIL", Anything, "bIHl"},
  161.     {Anything, "B", Anything, "b"},
  162. };
  163.  
  164.  
  165. /*
  166.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  167.  */
  168. static Rule     C_rules[] =
  169. {
  170.     {Nothing, "CH", "^", "k"},
  171.     {"^E", "CH", Anything, "k"},
  172.     {Anything, "CH", Anything, "CH"},
  173.     {" S", "CI", "#", "sAY"},
  174.     {Anything, "CI", "A", "SH"},
  175.     {Anything, "CI", "O", "SH"},
  176.     {Anything, "CI", "EN", "SH"},
  177.     {Anything, "C", "+", "s"},
  178.     {Anything, "CK", Anything, "k"},
  179.     {Anything, "COM", "%", "kAHm"},
  180.     {Anything, "C", Anything, "k"},
  181. };
  182.  
  183.  
  184. /*
  185.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  186.  */
  187. static Rule     D_rules[] =
  188. {
  189.     {"#:", "DED", Nothing, "dIHd"},
  190.     {".E", "D", Nothing, "d"},
  191.     {"#^:E", "D", Nothing, "t"},
  192.     {Nothing, "DE", "^#", "dIH"},
  193.     {Nothing, "DO", Nothing, "dUW"},
  194.     {Nothing, "DOES", Anything, "dAHz"},
  195.     {Nothing, "DOING", Anything, "dUWIHNG"},
  196.     {Nothing, "DOW", Anything, "dAW"},
  197.     {Anything, "DU", "A", "jUW"},
  198.     {Anything, "D", Anything, "d"},
  199. };
  200.  
  201.  
  202. /*
  203.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  204.  */
  205. static Rule     E_rules[] =
  206. {
  207.     {"#:", "E", Nothing, Silent},
  208.     {"'^:", "E", Nothing, Silent},
  209.     {" :", "E", Nothing, "IY"},
  210.     {"#", "ED", Nothing, "d"},
  211.     {"#:", "E", "D ", Silent},
  212.     {Anything, "EV", "ER", "EHv"},
  213.     {Anything, "E", "^%", "IY"},
  214.     {Anything, "ERI", "#", "IYrIY"},
  215.     {Anything, "ERI", Anything, "EHrIH"},
  216.     {"#:", "ER", "#", "ER"},
  217.     {Anything, "ER", "#", "EHr"},
  218.     {Anything, "ER", Anything, "ER"},
  219.     {Nothing, "EVEN", Anything, "IYvEHn"},
  220.     {"#:", "E", "W", Silent},
  221.     {"T", "EW", Anything, "UW"},
  222.     {"S", "EW", Anything, "UW"},
  223.     {"R", "EW", Anything, "UW"},
  224.     {"D", "EW", Anything, "UW"},
  225.     {"L", "EW", Anything, "UW"},
  226.     {"Z", "EW", Anything, "UW"},
  227.     {"N", "EW", Anything, "UW"},
  228.     {"J", "EW", Anything, "UW"},
  229.     {"TH", "EW", Anything, "UW"},
  230.     {"CH", "EW", Anything, "UW"},
  231.     {"SH", "EW", Anything, "UW"},
  232.     {Anything, "EW", Anything, "YUw"},
  233.     {Anything, "E", "O", "IY"},
  234.     {"#:S", "ES", Nothing, "IHz"},
  235.     {"#:C", "ES", Nothing, "IHz"},
  236.     {"#:G", "ES", Nothing, "IHz"},
  237.     {"#:Z", "ES", Nothing, "IHz"},
  238.     {"#:X", "ES", Nothing, "IHz"},
  239.     {"#:J", "ES", Nothing, "IHz"},
  240.     {"#:CH", "ES", Nothing, "IHz"},
  241.     {"#:SH", "ES", Nothing, "IHz"},
  242.     {"#:", "E", "S ", Silent},
  243.     {"#:", "ELY", Nothing, "lIY"},
  244.     {"#:", "EMENT", Anything, "mEHnt"},
  245.     {Anything, "EFUL", Anything, "fUHl"},
  246.     {Anything, "EE", Anything, "IY"},
  247.     {Anything, "EARN", Anything, "ERn"},
  248.     {Nothing, "EAR", "^", "ER"},
  249.     {Anything, "EAD", Anything, "EHd"},
  250.     {"#:", "EA", Nothing, "IYAX"},
  251.     {Anything, "EA", "SU", "EH"},
  252.     {Anything, "EA", Anything, "IY"},
  253.     {Anything, "EIGH", Anything, "EY"},
  254.     {Anything, "EI", Anything, "IY"},
  255.     {Nothing, "EYE", Anything, "AY"},
  256.     {Anything, "EY", Anything, "IY"},
  257.     {Anything, "EU", Anything, "YUw"},
  258.     {Anything, "E", Anything, "EH"},
  259. };
  260.  
  261.  
  262. /*
  263.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  264.  */
  265. static Rule     F_rules[] =
  266. {
  267.     {Anything, "FUL", Anything, "fUHl"},
  268.     {Anything, "F", Anything, "f"},
  269. };
  270.  
  271.  
  272. /*
  273.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  274.  */
  275. static Rule     G_rules[] =
  276. {
  277.     {Anything, "GIV", Anything, "gIHv"},
  278.     {Nothing, "G", "I^", "g"},
  279.     {Anything, "GE", "T", "gEH"},
  280.     {"SU", "GGES", Anything, "gjEHs"},
  281.     {Anything, "GG", Anything, "g"},
  282.     {" B#", "G", Anything, "g"},
  283.     {Anything, "G", "+", "j"},
  284.     {Anything, "GREAT", Anything, "grEYt"},
  285.     {"#", "GH", Anything, Silent},
  286.     {Anything, "G", Anything, "g"},
  287. };
  288.  
  289.  
  290. /*
  291.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  292.  */
  293. static Rule     H_rules[] =
  294. {
  295.     {Nothing, "HAV", Anything, "HHAEv"},
  296.     {Nothing, "HERE", Anything, "HHIYr"},
  297.     {Nothing, "HOUR", Anything, "AWER"},
  298.     {Anything, "HOW", Anything, "HHAW"},
  299.     {Anything, "H", "#", "HH"},
  300.     {Anything, "H", Anything, Silent},
  301. };
  302.  
  303.  
  304. /*
  305.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  306.  */
  307. static Rule     I_rules[] =
  308. {
  309.     {Nothing, "IN", Anything, "IHn"},
  310.     {Nothing, "I", Nothing, "AY"},
  311.     {Anything, "IN", "D", "AYn"},
  312.     {Anything, "IER", Anything, "IYER"},
  313.     {"#:R", "IED", Anything, "IYd"},
  314.     {Anything, "IED", Nothing, "AYd"},
  315.     {Anything, "IEN", Anything, "IYEHn"},
  316.     {Anything, "IE", "T", "AYEH"},
  317.     {" :", "I", "%", "AY"},
  318.     {Anything, "I", "%", "IY"},
  319.     {Anything, "IE", Anything, "IY"},
  320.     {Anything, "I", "^+:#", "IH"},
  321.     {Anything, "IR", "#", "AYr"},
  322.     {Anything, "IZ", "%", "AYz"},
  323.     {Anything, "IS", "%", "AYz"},
  324.     {Anything, "I", "D%", "AY"},
  325.     {"+^", "I", "^+", "IH"},
  326.     {Anything, "I", "T%", "AY"},
  327.     {"#^:", "I", "^+", "IH"},
  328.     {Anything, "I", "^+", "AY"},
  329.     {Anything, "IR", Anything, "ER"},
  330.     {Anything, "IGH", Anything, "AY"},
  331.     {Anything, "ILD", Anything, "AYld"},
  332.     {Anything, "IGN", Nothing, "AYn"},
  333.     {Anything, "IGN", "^", "AYn"},
  334.     {Anything, "IGN", "%", "AYn"},
  335.     {Anything, "IQUE", Anything, "IYk"},
  336.     {Anything, "I", Anything, "IH"},
  337. };
  338.  
  339.  
  340. /*
  341.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  342.  */
  343. static Rule     J_rules[] =
  344. {
  345.     {Anything, "J", Anything, "j"},
  346. };
  347.  
  348.  
  349. /*
  350.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  351.  */
  352. static Rule     K_rules[] =
  353. {
  354.     {Nothing, "K", "N", Silent},
  355.     {Anything, "K", Anything, "k"},
  356. };
  357.  
  358.  
  359. /*
  360.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  361.  */
  362. static Rule     L_rules[] =
  363. {
  364.     {Anything, "LO", "C#", "lOW"},
  365.     {"L", "L", Anything, Silent},
  366.     {"#^:", "L", "%", "AXl"},
  367.     {Anything, "LEAD", Anything, "lIYd"},
  368.     {Anything, "L", Anything, "l"},
  369. };
  370.  
  371.  
  372. /*
  373.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  374.  */
  375. static Rule     M_rules[] =
  376. {
  377.     {Anything, "MOV", Anything, "mUWv"},
  378.     {Anything, "M", Anything, "m"},
  379. };
  380.  
  381.  
  382. /*
  383.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  384.  */
  385. static Rule     N_rules[] =
  386. {
  387.     {"E", "NG", "+", "nj"},
  388.     {Anything, "NG", "R", "NGg"},
  389.     {Anything, "NG", "#", "NGg"},
  390.     {Anything, "NGL", "%", "NGgAXl"},
  391.     {Anything, "NG", Anything, "NG"},
  392.     {Anything, "NK", Anything, "NGk"},
  393.     {Nothing, "NOW", Nothing, "nAW"},
  394.     {Anything, "N", Anything, "n"},
  395. };
  396.  
  397.  
  398. /*
  399.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  400.  */
  401. static Rule     O_rules[] =
  402. {
  403.     {Anything, "OF", Nothing, "AXv"},
  404.     {Anything, "OROUGH", Anything, "EROW"},
  405.     {"#:", "OR", Nothing, "ER"},
  406.     {"#:", "ORS", Nothing, "ERz"},
  407.     {Anything, "OR", Anything, "AOr"},
  408.     {Nothing, "ONE", Anything, "wAHn"},
  409.     {Anything, "OW", Anything, "OW"},
  410.     {Nothing, "OVER", Anything, "OWvER"},
  411.     {Anything, "OV", Anything, "AHv"},
  412.     {Anything, "O", "^%", "OW"},
  413.     {Anything, "O", "^EN", "OW"},
  414.     {Anything, "O", "^I#", "OW"},
  415.     {Anything, "OL", "D", "OWl"},
  416.     {Anything, "OUGHT", Anything, "AOt"},
  417.     {Anything, "OUGH", Anything, "AHf"},
  418.     {Nothing, "OU", Anything, "AW"},
  419.     {"H", "OU", "S#", "AW"},
  420.     {Anything, "OUS", Anything, "AXs"},
  421.     {Anything, "OUR", Anything, "AOr"},
  422.     {Anything, "OULD", Anything, "UHd"},
  423.     {"^", "OU", "^L", "AH"},
  424.     {Anything, "OUP", Anything, "UWp"},
  425.     {Anything, "OU", Anything, "AW"},
  426.     {Anything, "OY", Anything, "OY"},
  427.     {Anything, "OING", Anything, "OWIHNG"},
  428.     {Anything, "OI", Anything, "OY"},
  429.     {Anything, "OOR", Anything, "AOr"},
  430.     {Anything, "OOK", Anything, "UHk"},
  431.     {Anything, "OOD", Anything, "UHd"},
  432.     {Anything, "OO", Anything, "UW"},
  433.     {Anything, "O", "E", "OW"},
  434.     {Anything, "O", Nothing, "OW"},
  435.     {Anything, "OA", Anything, "OW"},
  436.     {Nothing, "ONLY", Anything, "OWnlIY"},
  437.     {Nothing, "ONCE", Anything, "wAHns"},
  438.     {Anything, "ON'T", Anything, "OWnt"},
  439.     {"C", "O", "N", "AA"},
  440.     {Anything, "O", "NG", "AO"},
  441.     {"^:", "O", "N", "AH"},
  442.     {"I", "ON", Anything, "AXn"},
  443.     {"#:", "ON", Nothing, "AXn"},
  444.     {"#^", "ON", Anything, "AXn"},
  445.     {Anything, "O", "ST ", "OW"},
  446.     {Anything, "OF", "^", "AOf"},
  447.     {Anything, "OTHER", Anything, "AHDHER"},
  448.     {Anything, "OSS", Nothing, "AOs"},
  449.     {"#^:", "OM", Anything, "AHm"},
  450.     {Anything, "O", Anything, "AA"},
  451. };
  452.  
  453.  
  454. /*
  455.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  456.  */
  457. static Rule     P_rules[] =
  458. {
  459.     {Anything, "PH", Anything, "f"},
  460.     {Anything, "PEOP", Anything, "pIYp"},
  461.     {Anything, "POW", Anything, "pAW"},
  462.     {Anything, "PUT", Nothing, "pUHt"},
  463.     {Anything, "P", Anything, "p"},
  464. };
  465.  
  466.  
  467. /*
  468.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  469.  */
  470. static Rule     Q_rules[] =
  471. {
  472.     {Anything, "QUAR", Anything, "kwAOr"},
  473.     {Anything, "QU", Anything, "kw"},
  474.     {Anything, "Q", Anything, "k"},
  475. };
  476.  
  477.  
  478. /*
  479.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  480.  */
  481. static Rule     R_rules[] =
  482. {
  483.     {Nothing, "RE", "^#", "rIY"},
  484.     {Anything, "R", Anything, "r"},
  485. };
  486.  
  487.  
  488. /*
  489.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  490.  */
  491. static Rule     S_rules[] =
  492. {
  493.     {Anything, "SH", Anything, "SH"},
  494.     {"#", "SION", Anything, "ZHAXn"},
  495.     {Anything, "SOME", Anything, "sAHm"},
  496.     {"#", "SUR", "#", "ZHER"},
  497.     {Anything, "SUR", "#", "SHER"},
  498.     {"#", "SU", "#", "ZHUW"},
  499.     {"#", "SSU", "#", "SHUW"},
  500.     {"#", "SED", Nothing, "zd"},
  501.     {"#", "S", "#", "z"},
  502.     {Anything, "SAID", Anything, "sEHd"},
  503.     {"^", "SION", Anything, "SHAXn"},
  504.     {Anything, "S", "S", Silent},
  505.     {".", "S", Nothing, "z"},
  506.     {"#:.E", "S", Nothing, "z"},
  507.     {"#^:##", "S", Nothing, "z"},
  508.     {"#^:#", "S", Nothing, "s"},
  509.     {"U", "S", Nothing, "s"},
  510.     {" :#", "S", Nothing, "z"},
  511.     {Nothing, "SCH", Anything, "sk"},
  512.     {Anything, "S", "C+", Silent},
  513.     {"#", "SM", Anything, "zm"},
  514.     {"#", "SN", "'", "zAXn"},
  515.     {Anything, "S", Anything, "s"},
  516. };
  517.  
  518.  
  519. /*
  520.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  521.  */
  522. static Rule     T_rules[] =
  523. {
  524.     {Nothing, "THE", Nothing, "DHAX"},
  525.     {Anything, "TO", Nothing, "tUW"},
  526.     {Anything, "THAT", Nothing, "DHAEt"},
  527.     {Nothing, "THIS", Nothing, "DHIHs"},
  528.     {Nothing, "THEY", Anything, "DHEY"},
  529.     {Nothing, "THERE", Anything, "DHEHr"},
  530.     {Anything, "THER", Anything, "DHER"},
  531.     {Anything, "THEIR", Anything, "DHEHr"},
  532.     {Nothing, "THAN", Nothing, "DHAEn"},
  533.     {Nothing, "THEM", Nothing, "DHEHm"},
  534.     {Anything, "THESE", Nothing, "DHIYz"},
  535.     {Nothing, "THEN", Anything, "DHEHn"},
  536.     {Anything, "THROUGH", Anything, "THrUW"},
  537.     {Anything, "THOSE", Anything, "DHOWz"},
  538.     {Anything, "THOUGH", Nothing, "DHOW"},
  539.     {Nothing, "THUS", Anything, "DHAHs"},
  540.     {Anything, "TH", Anything, "TH"},
  541.     {"#:", "TED", Nothing, "tIHd"},
  542.     {"S", "TI", "#N", "CH"},
  543.     {Anything, "TI", "O", "SH"},
  544.     {Anything, "TI", "A", "SH"},
  545.     {Anything, "TIEN", Anything, "SHAXn"},
  546.     {Anything, "TUR", "#", "CHER"},
  547.     {Anything, "TU", "A", "CHUW"},
  548.     {Nothing, "TWO", Anything, "tUW"},
  549.     {Anything, "T", Anything, "t"},
  550. };
  551.  
  552.  
  553. /*
  554.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  555.  */
  556. static Rule     U_rules[] =
  557. {
  558.     {Nothing, "UN", "I", "yUWn"},
  559.     {Nothing, "UN", Anything, "AHn"},
  560.     {Nothing, "UPON", Anything, "AXpAOn"},
  561.     {"T", "UR", "#", "UHr"},
  562.     {"S", "UR", "#", "UHr"},
  563.     {"R", "UR", "#", "UHr"},
  564.     {"D", "UR", "#", "UHr"},
  565.     {"L", "UR", "#", "UHr"},
  566.     {"Z", "UR", "#", "UHr"},
  567.     {"N", "UR", "#", "UHr"},
  568.     {"J", "UR", "#", "UHr"},
  569.     {"TH", "UR", "#", "UHr"},
  570.     {"CH", "UR", "#", "UHr"},
  571.     {"SH", "UR", "#", "UHr"},
  572.     {Anything, "UR", "#", "yUHr"},
  573.     {Anything, "UR", Anything, "ER"},
  574.     {Anything, "U", "^ ", "AH"},
  575.     {Anything, "U^^", Anything, "AH"},
  576.     {Anything, "UY", Anything, "AY"},
  577.     {" G", "U", "#", Silent},
  578.     {"G", "U", "%", Silent},
  579.     {"G", "U", "#", "w"},
  580.     {"#N", "U", Anything, "YUw"},
  581.     {"T", "U", Anything, "UW"},
  582.     {"S", "U", Anything, "UW"},
  583.     {"R", "U", Anything, "UW"},
  584.     {"D", "U", Anything, "UW"},
  585.     {"L", "U", Anything, "UW"},
  586.     {"Z", "U", Anything, "UW"},
  587.     {"N", "U", Anything, "UW"},
  588.     {"J", "U", Anything, "UW"},
  589.     {"TH", "U", Anything, "UW"},
  590.     {"CH", "U", Anything, "UW"},
  591.     {"SH", "U", Anything, "UW"},
  592.     {Anything, "U", Anything, "YUw"},
  593. };
  594.  
  595.  
  596. /*
  597.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  598.  */
  599. static Rule     V_rules[] =
  600. {
  601.     {Anything, "VIEW", Anything, "vYUw"},
  602.     {Anything, "V", Anything, "v"},
  603. };
  604.  
  605.  
  606. /*
  607.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  608.  */
  609. static Rule     W_rules[] =
  610. {
  611.     {Nothing, "WERE", Anything, "wER"},
  612.     {Anything, "WA", "S", "wAA"},
  613.     {Anything, "WA", "T", "wAA"},
  614.     {Anything, "WERE", Anything, "WHEHr"},
  615.     {Anything, "WHAT", Anything, "WHAAt"},
  616.     {Anything, "WHOL", Anything, "HHOWl"},
  617.     {Anything, "WHO", Anything, "HHUW"},
  618.     {Anything, "WH", Anything, "WH"},
  619.     {Anything, "WAR", Anything, "wAOr"},
  620.     {Anything, "WOR", "^", "wER"},
  621.     {Anything, "WR", Anything, "r"},
  622.     {Anything, "W", Anything, "w"},
  623. };
  624.  
  625.  
  626. /*
  627.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  628.  */
  629. static Rule     X_rules[] =
  630. {
  631.     {Anything, "X", Anything, "ks"},
  632. };
  633.  
  634.  
  635. /*
  636.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  637.  */
  638. static Rule     Y_rules[] =
  639. {
  640.     {Anything, "YOUNG", Anything, "yAHNG"},
  641.     {Nothing, "YOU", Anything, "yUW"},
  642.     {Nothing, "YES", Anything, "yEHs"},
  643.     {Nothing, "Y", Anything, "y"},
  644.     {"#^:", "Y", Nothing, "IY"},
  645.     {"#^:", "Y", "I", "IY"},
  646.     {" :", "Y", Nothing, "AY"},
  647.     {" :", "Y", "#", "AY"},
  648.     {" :", "Y", "^+:#", "IH"},
  649.     {" :", "Y", "^#", "AY"},
  650.     {Anything, "Y", Anything, "IH"},
  651. };
  652.  
  653.  
  654. /*
  655.  * *    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  656.  */
  657. static Rule     Z_rules[] =
  658. {
  659.     {Anything, "Z", Anything, "z"},
  660. };
  661.  
  662. Rule           *Rules[] =
  663. {
  664.     punct_rules,
  665.     A_rules, B_rules, C_rules, D_rules, E_rules, F_rules, G_rules,
  666.     H_rules, I_rules, J_rules, K_rules, L_rules, M_rules, N_rules,
  667.     O_rules, P_rules, Q_rules, R_rules, S_rules, T_rules, U_rules,
  668.     V_rules, W_rules, X_rules, Y_rules, Z_rules
  669. };
  670.